Python 的变量

        变量是计算机内存中的一块区域，变量可以存储规定范围内的值，而且值可以改变。
        python下变量是对一个数据的引用。

变量的命名：

  1. 变量名由字母、数字、下划线组成。
  2. 变量不能以数字开头
  3. 不可以使用关键字
  4. a a1 _a，这些都是合法的变量名
    表达式是将不同的数据（包括变量、函数）用运算符号按一定规则连接起来的一种式子。

Python对象的三要素：id、type、value

  • id：是对象的唯一标识，是对象在内存中的存储地址
  • type：是对象的数据类型
  • value：是对象的值，是对象在内存中存放的数据

        还有一个name，理解为变量名

###变量的赋值：
        变量的声明和定义的过程

1
2
3
4
5
6
7
8
9
10
11
12
In [1]: a = 1
 
In [2]: id(a)
Out[2]: 13933672
 
In [3]: id(a)
Out[3]: 13933672
 
In [4]: a = 2
 
In [5]: id(a)
Out[5]: 13933648

        id（a）表示变量a在内存里的位置，a的变量值发生改变，在内存中的位置也发生改变。

Python 运算符

1.算数运算符

        +，一个值加上另一个值，也可以是一个字符串加上另一个字符串

1
2
3
4
5
In [38]: 3 + 4
Out[38]: 7
 
In [39]: 'a' + 'b'
Out[39]: 'ab'

        -，一个值减去另一个值

1
2
In [40]: 5 - 4
Out[40]: 1

        *，一个值乘以另一个值

1
2
In [44]: 3 * 4
Out[44]: 12

        /，一个值除以另一个值

1
2
In [45]: 4 / 3
Out[45]: 1

        注意：这里只取整数，如果想要小数点，那么除法运算的两个数值至少一个要是浮点数

1
2
3
4
5
In [46]: 4.0 / 3
Out[46]: 1.3333333333333333
 
In [47]: 4 / 3.0
Out[47]: 1.3333333333333333

        //，只取整除，数值带上小数点也只取整数

1
2
3
4
5
6
7
8
In [48]: 4.0 // 3
Out[48]: 1.0
 
In [49]: 4 // 3.0
Out[49]: 1.0
 
In [50]: 4 // 3
Out[50]: 1

        %，表示取余

1
2
3
4
5
6
7
8
In [51]: 4 % 3
Out[51]: 1
 
In [52]: 5 % 3
Out[52]: 2
 
In [53]: 6 % 3
Out[53]: 0

        **，表示乘方

1
2
3
4
5
In [54]: 2 ** 3
Out[54]: 8
 
In [55]: 2 ** 10
Out[55]: 1024

2.关系（比较）运算符

        >，大于

1
2
3
4
5
In [56]: 2 > 1
Out[56]: True
 
In [57]: 1 > 2
Out[57]: False

        <，小于

1
2
3
4
5
In [58]: 2 < 3
Out[58]: True
 
In [59]: 3 < 2
Out[59]: False

        >=，大于等于

1
2
3
4
5
6
7
8
In [60]: 2 >= 1
Out[60]: True
 
In [61]: 2 >= 2
Out[61]: True
 
In [62]: 2 >= 3
Out[62]: False

        <=，小于等于

1
2
3
4
5
6
7
8
In [63]: 2 <=3
Out[63]: True
 
In [64]: 3 <= 3
Out[64]: True
 
In [65]: 4 <= 3
Out[65]: False

        ==，恒等于

1
2
3
4
5
In [72]: 1 == 1
Out[72]: True
 
In [73]: 1 == 2
Out[73]: False

        !=，不等于

1
2
3
4
5
In [74]: 1 != 2
Out[74]: True
 
In [75]: 2 != 2
Out[75]: False

3.赋值运算符

        =，表示直接给变量赋值，如果是字符串必须加上引号

1
2
3
In [11]: x = 3
 
In [12]: y = 'abc'

        说明：可以通过 type（）命令查看变量是数字还是字符串

1
2
3
4
5
In [15]: type(x)
Out[15]: int
 
In [16]: type(y)
Out[16]: str

        +=，表示变量 的值再加上一个值（a=a+b）

1
2
3
4
In [13]: x += 2
 
In [14]: x
Out[14]: 5

        -=，表示变量的值再减去一个值（a=a-b）

1
2
3
4
In [17]: x -= 1
 
In [18]: x
Out[18]: 4

        *=，表示变量的值再乘以一个值（a=a*b）

1
2
3
4
In [19]: x *= 2
 
In [20]: x
Out[20]: 8

        /=，表示变量的值再除以一个值（a=a/b）

1
2
3
4
In [21]: x /= 4
 
In [22]: x
Out[22]: 2

        %=，表示取余，变量被一个数整除后，还剩多少值（a=a%b）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
In [29]: x=10
 
In [30]: x %= 3
 
In [31]: x
Out[31]: 1
 
In [32]: x=9
 
In [33]: x %= 3
 
In [34]: x
Out[34]: 0
 
In [35]: x=11
 
In [36]: x %= 3
 
In [37]: x
Out[37]: 2

        **=，表示乘方，a的b次方（a=a**b）

1
2
3
4
5
6
In [66]: x = 2
 
In [67]: x **= 3
 
In [68]: x
Out[68]: 8

        //=，表示整除，（a=a//b）

1
2
3
4
5
6
7
In [68]: x
Out[68]: 8
 
In [69]: x //= 3
 
In [70]: x
Out[70]: 2

4.逻辑运算符

        and，逻辑与：true and false。表示一个成立and另一个也成立，返回值是 true

1
2
In [77]: 3 > 2 and 1 < 2
Out[77]: True

        如果其中一个不成立，返回值是 false

1
2
3
4
5
In [78]: 1 == 2 and 2 > 1
Out[78]: False
 
In [79]: 1 < 2 and 1 != 1
Out[79]: False

        or，逻辑或：false or true，表示只要有一个成立那么返回就是true

1
2
In [80]: 1 < 2 or 1 != 1
Out[80]: True

        not，逻辑非：not true，表示取反

1
2
3
4
5
In [81]: not 1 < 2
Out[81]: False
 
In [82]: not 1 != 1
Out[82]: True

5.身份运算符

        身份运算符用来判断两个变量的引用对象是否指向统一个内存的对象，即 id(varibale1)?=id(variable2)。

  • is：判断两个标识符是不是引用自一个对象
  • is not：判断两个标识符是不是引用不同对象
1
2
3
4
5
6
7
8
9
In [88]: a = [1,2,3]
 
In [89]: b = [1,2,3]
 
In [90]: print ( a == b )
True
 
In [91]: print ( a is b )
False

        因为变量 a 和变量 b 的 value 是一样的， == 运算符比较的变量的 value ，所以返回true。is 是判断两个变量是否引用同一个对象，也就是比较的是 id ，所以返回 false。

6.成员关系运算符

        成员运算符能够判断一个指定对象是否是作为一个容器中的元素，由此来判断两个对象间的关系。
        容器：包含了其他对象的引用的数据类型。

  • in：当一个对象存在一个容器中时为 true
  • not in：当一个对象不在一个容器中时为 true
1
2
3
4
5
6
7
8
9
10
11
In [93]: a = 1
 
In [94]: b = 2
 
In [95]: c = [1,3,4]
 
In [96]: a in c
Out[98]: True
 
In [97]: b in c
Out[99]: False

7.位运算符

        在 Python 中 |、&、^、~等运算符的意思不在于处理逻辑关系，而是二进制数据的为运算，数字以二进制形式的补码存储和计算，以原码结果来显示。若数字为正值，它的补码就是原码本身、若为负值，则它的补码为源码减1再按位取反。两个数字的计算本质是两个二进制补码的计算。

  • |：按位或运算符，只要对应的二个二进位有一个为1时，结果位就为1.
  • &：按位与运算符，参与运算的两个值，如果两个相应的位都为1，则该位为的结果为1，否则为0
  • ^：按位异或运算符，当两对应的二进位相异时，结果为1
  • ~：按位取反运算符，对数据的每个二进制位取反，即把1变为0，把0变为1
1
2
3
4
5
6
7
8
9
10
11
12
13
a = 0011 1100
 
b = 0000 1101
 
-----------------
 
a&b = 0000 1100
 
a|b = 0011 1101
 
a^b = 0011 0001
 
~a = 1100 0011

8.位移运算符

        位移运算符是非常有效率的计算方法之一，在对数学运算和对程序执行效率要求高的程序中推荐使用。

  • <<：左移动运算符，运算数的各二进位全部左移若干位，由 “<<” 右边的数值指定移动的位数，高位丢弃，低位补0

  • ：右移动运算符，把 “>>” 左边的运算数的各二进位全部右移若干位， “>>” 右边的数指定移动的位数

1
2
3
4
5
a = 0011 1100
 
a << 2 1111 0000 #结果为240
 
a >> 2 0000 1111 #结果为15

Python运算符优先级

        下标列出了从最高到最低优先级的所有运算符：

运算符 描述
** 指数 (最高优先级)
~ + - 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % // 乘，除，取模和取整除
+ - 加法减法
>> << 右移，左移运算符
& 位 ‘AND’
^ \ 位运算符
<= < > >= 比较运算符
<> == != 等于运算符
= %= /= //= -= += = *= 赋值运算符
is ，is not 身份运算符
in ，not in 成员运算符
not ，or ，and 逻辑运算符

        以下实例演示了python所有运算符优先级的操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#!/usr/bin/python
# -*- coding: UTF-8 -*-
  
a = 20
b = 10
c = 15
d = 5
e = 0
  
e = (a + b) * c / d #( 30 * 15 ) / 5
print "(a + b) * c / d 运算结果为：", e
  
e = ((a + b) * c) / d # (30 * 15 ) / 5
print "((a + b) * c) / d 运算结果为：", e
  
e = (a + b) * (c / d); # (30) * (15/5)
print "(a + b) * (c / d) 运算结果为：", e
  
e = a + (b * c) / d; # 20 + (150/5)
print "a + (b * c) / d 运算结果为：", e

        输出结果：

1
2
3
4
(a + b) * c / d 运算结果为： 90
((a + b) * c) / d 运算结果为： 90
(a + b) * (c / d) 运算结果为： 90
a + (b * c) / d 运算结果为： 50